cl: support Gloas alpha.12 progressive SSZ and spectests - #22912

Reviewed the full diff. Approve with nits.

The hashing core is sound and I could verify it independently: the light-client branch sizes reproduce from progressiveProof on the 46-field state and 13-field body (FinalizedBranchSizeGloas=9, CurrentSyncCommitteeBranchSizeGloas=11, ExecutionBranchSizeGloas=11 = 2 bid + 1 signed-bid + 8 body), proof ordering is leaf-to-root as SSZ expects, and CI is green with the alpha.12 fixtures including ssz_static/BeaconState and the light-client proof cases.

Should fix

cl/merkle_tree/merkle_root.go:255 — panic format args are swapped.

panic(fmt.Sprintf("Can't create TreeRoot: unsported type %T at index %d", i, obj))

%T gets the index and %d gets the value. The correct version is 150 lines up in HashTreeRoot (..., obj, i). Also unsported -> unsupported.

Worth discussing

The new spectest handlers reimplement the logic they test. gossip.go grows ~400 lines of gossip validation for BLS-to-execution changes, sync committee messages and sync contributions, but erigon already ships bls_to_execution_change_service.go, sync_committee_messages_service.go and sync_contribution_service.go in cl/phase1/network/services/. The new handlers check a test-local reimplementation against the fixtures, so the shipped validators get no coverage from them and the two can drift silently. rewards.go has the same shape but is milder — it does call production BaseReward / EligibleValidatorsIndicies / GetUnslashedIndiciesSet and only re-derives the delta combination, which is hard to avoid since erigon computes the components fused. I would route the gossip handlers through the services if that is feasible. The existing gossipAttesterSlashingHandler set this precedent, but it is worth not extending it. On the plus side, rewards.go removes a t.Skip, which is what the repo policy wants.

solid.Attestation.HashSSZ() now branches on an unexported version that most constructors never set. cl/aggregation/pool_impl.go:114 and :167 build merged aggregates as bare &solid.Attestation{...} with no version, so a pooled Gloas aggregate hashes with the pre-Gloas container layout. I traced the live paths and none of them are consensus-critical today: the block-body root goes through the explicit HashSSZProgressive schema regardless of element version, and this PR correctly plugs the aggregate-and-proof signing and verification paths (gossip service, REST pool handler, devvalidator, ToAttestation). But a getter that silently returns the wrong root is a trap for the next caller. At minimum, propagate the version in the two pool merges — Copy() already preserves it, so the asymmetry is easy to miss.

BitList.HashSSZProgressive mixes two length sources.

bitLength := u.Bits()                          // scans all of u.u, past u.l
packed := append([]byte(nil), u.Bytes()...)    // u.u[:u.l] only
packed = packed[:(bitLength+7)/8]              // can exceed cap(packed) -> panic

HashSSZ derives both from u.u[:u.l] via parseBitlist. If a BitList ever carries a non-zero byte past u.l, the progressive path panics where the old one merely disagreed. Deriving the length from u.Bytes() costs nothing and removes the class.

ProgressiveContainerRoot is exported but only reached through ProgressiveContainerRootAll. The interesting branch — zero-chunk padding at inactive field positions — has no caller and no test. Either add a vector for it or unexport it until #22683 needs it.

ExecutionBranchSizeGloas lost its explanation. The deleted comment (get_generalized_index(BeaconBlockBody, 'signed_execution_payload_bid', 'message', 'parent_block_hash')) was the only thing telling a reader why a method named ExecutionBlockHashMerkleProof proves field 0 = ParentBlockHash. That is the surprising-edge-case category the comment policy keeps. A one-liner is worth it.

Nits

• NewBeaconBody allocates six non-progressive lists in the struct literal and then resetGloasProgressiveLists() discards all of them on the Gloas path. ExecutionRequests.UnmarshalJSON does the same with five. Move the allocation into the version branch.
• ProgressiveBitlistRoot and ProgressiveBasicListRoot are byte-for-byte identical, and both copy byte-by-byte where packBits (same package, list.go) already does it with copy.
• hashPair uses crypto/sha256 directly; everything else in merkle_tree goes through common/crypto.Sha256.
• progressiveProof makes three defensive copies of the chunk slice per recursion level.
• pool.go: the three new poolingFailure{Index: len(failures)} should use the request index. It matches the existing convention in that file, so either fix all four together or leave all four.
• MaxBuilderDepositRequestsPerPayload 256 -> 64, MinBuilderWithdrawabilityDelay 8192 -> 64, BuilderWithdrawalPrefix 0x03 -> 0xB0: only mainnet fixtures are wired up (test-fixtures.json has no cl_minimal), so these rest entirely on the alpha.12 mainnet preset. Worth a second pair of eyes against the spec constants.

Checked and fine

ValidatorSet progressive segment bookkeeping (append/set/copy/clear paths, per-closure hash buffers, no shared-buffer race), beaconStateHasher.run() error plumbing (buffered channel, no deadlock), the SetVersion dirty-leaf list (index 24 is genuinely shared between latestExecutionPayloadHeader and latestBlockHash, so marking it is correct and not a typo), ElementProof on limit-0 progressive lists (both callers are Gloas-guarded), and the cl/ssz/decode.go static-element slicing change (BitVector.EncodingSizeSSZ uses bitCap, so it is safe before decode).

Thanks for the thorough review. I addressed the correctness and robustness items you called out:

• fixed the progressive container panic formatting and typo;
• propagated the slot-derived fork version through first-insert and merged aggregation-pool paths, while copying caller-owned attestations and returning aggregation errors;
• made progressive bitlist hashing, length checks, and merges operate on logical bytes, including compact-to-padded and padded-to-compact regression tests;
• added an inactive-field ProgressiveContainerRoot vector;
• restored the one-line Gloas parent-block-hash proof explanation;
• added nil/config and saturating-limit coverage for indexed attestations.

The gossip spectest-handler consolidation is intentionally left out of this PR because it is a broader production-service refactor; this PR keeps the fixture coverage without mixing that architectural change into the alpha.12 catch-up.

The branch is now rebased onto current main. Focused CL/spectest/network tests, repeated lint, and the required Erigon/integration builds pass locally. The refreshed GitHub checks are running now. Please take another look when convenient.